home *** CD-ROM | disk | FTP | other *** search
/ Tech Arsenal 1 / Tech Arsenal (Arsenal Computer).ISO / tek-01 / pct2.zip / CHAP3.DOC < prev    next >
Text File  |  1990-08-03  |  22KB  |  510 lines

  1.  
  2.  
  3.                                                                             16
  4.  
  5.                                  CHAPTER 3 - ASMHELP
  6.  
  7.  
  8.              We are now going to introduce both the 8086 registers and a
  9.              program for looking at them. You are going to get information
  10.              flying at you at a rapid pace, so read both this and the next
  11.              chapter carefully and slowly. 
  12.  
  13.  
  14.              REGISTERS
  15.  
  16.              The 8086 has a number of registers. Remember, registers are
  17.              places for storing data that are internal to the 8086 chip. They
  18.              are much faster, but there are very few of them.
  19.  
  20.              There are 6 registers that you can use for addition and subtrac-
  21.              tion of word (2 byte) sized numbers, as well as logical opera-
  22.              tions on word (2 byte) numbers or data. These registers are AX,
  23.              BX, CX, DX, SI, DI. In addition, there is a register which works
  24.              the same way, but has a special function in all high-level
  25.              languages (Basic, Pascal, C, etc.). This is BP, the base pointer.
  26.  
  27.              There is one more register that performs the same operations as
  28.              the above seven, but it is RESERVED for special use and should
  29.              never be used for anything. It is called SP (the stack pointer).
  30.  
  31.              There are 4 registers that tell the 8086 which memory segments
  32.              you are in. They just sit there and help the 8086 find things in
  33.              memory. You will learn how they work later. They are CS, DS, SS,
  34.              ES. (That is Code Segment, Data Segment, Stack Segment and Extra
  35.              Segment respectively). 
  36.  
  37.              There is the flags register which contains all the information
  38.              the 8086 needs to evaluate its state. We will learn about this
  39.              later. The flags register has no name, and there are machine
  40.              instructions for manipulating individual flags in the register.
  41.  
  42.              Finally, there is IP, the instruction pointer, which points to
  43.              the machine instructions. You have no direct access to this,
  44.              which is good because you would screw it up for certain. The 8086
  45.              handles the IP automatically and correctly.
  46.  
  47.              One word (two bytes or 16 bits) is the largest piece of data that
  48.              the 8086 can handle naturally. It is possible to handle larger
  49.              things, but we do it through software (which is slower), not
  50.              hardware (which is faster). Sometimes we want to handle things
  51.              one byte at a time as when we work with characters. The 8086
  52.              gives us this possibility by letting us divide the AX, BX, CX,
  53.              and DX registers into an upper half and a lower half. For any or
  54.              all of these registers, we can replace one 2 byte register by two
  55.              1 byte registers. The data in the full register stays the same,
  56.              but we can look at each half. The two parts of AX are called AH
  57.              (for A high) and AL (for A low). 
  58.  
  59.                  |------AX------|
  60.                  0000000000000000
  61.                  |--AH--||--AL--|
  62.  
  63.  
  64.  
  65.  
  66.  
  67.              Chapter 3 - ASMHELP.OBJ                                        17
  68.              _______________________
  69.  
  70.              This is the 16 bit binary number 0 in the AX register. Using AX
  71.              allows us to manipulate all 16 bits. Using AH allows us to
  72.              manipulate the upper 8 bits (without affecting the lower 8 bits),
  73.              and using AL allows us to manipulate the lower 8 bits without
  74.              affecting the upper 8 bits. Similarly, for BX we have BH, BL, for
  75.              CX we have CH, CL, and for DX we have DH, DL.
  76.  
  77.  
  78.              SHOW_REGS
  79.  
  80.              We have named all the registers, now let's take a look at them.
  81.              Included in the module asmhelp.obj is a program called show_regs.
  82.              It shows all the above registers on the top 10 lines of your
  83.              screen and allows you to enter data normally underneath. 
  84.  
  85.              When you call show_regs, it puts the current value of all the
  86.              registers on the screen. Those values stay on the screen until
  87.              the next call - i.e. the program does not change what is on the
  88.              screen even though the registers may be changing value. You need
  89.              to call show_regs every time that you want to see the current
  90.              values of the registers.
  91.  
  92.              The first time you call show_regs, it clears the screen so you
  93.              should call it right at the beginning of the program in order to
  94.              initialize the screen.
  95.  
  96.              This time we want temp2.asm for a template; we will call this
  97.              program prog3.asm, so make a copy of temp2.asm and give it the
  98.              new name.  Let's take a look at it. The only differences are (1)
  99.              there are a lot more programs in the EXTRN statements and (2) in
  100.              the data segment DATASTUFF there are these definitons:
  101.  
  102.              ax_byte  db   2
  103.              bx_byte  db   2
  104.              cx_byte  db   2
  105.              etc.
  106.  
  107.              These will be used for show_regs later, but you need to learn a
  108.              few assembler instructions first.
  109.  
  110.              Here's our next program:
  111.  
  112.              TEMP2.ASM
  113.              + + + + + + + + START CODE BELOW THIS LINE
  114.                  call show_regs
  115.  
  116.              label_one:
  117.                  call get_hex
  118.                  call show_regs
  119.  
  120.                  call get_num
  121.                  call show_regs
  122.  
  123.                  jmp  label_one
  124.  
  125.              + + + + + + + + END CODE ABOVE THIS LINE
  126.  
  127.  
  128.  
  129.  
  130.  
  131.              The PC Assembler Tutor                                         18
  132.              ______________________
  133.  
  134.              That's all the program does. It asks for a number, then calls
  135.              show_regs to show us what is in the registers. Note that one of
  136.              the numbers is hex while the other number is decimal.
  137.  
  138.              Compile this, and link it with 
  139.  
  140.              >link prog3+\asmhelp ;
  141.  
  142.              and we're ready to go.
  143.  
  144.              The program reads information in the computer to find out what
  145.              kind of monitor you have and where the screen output goes. It
  146.              then puts the register information on the top lines. If it
  147.              doesn't appear there, we have a screwup somewhere. The text
  148.              should appear in black and white, but if you have a color monitor
  149.              you can make it a blue background with white letters.{1} 
  150.  
  151.  
  152.              *********************** SCREEN SHOT ***************************
  153.  
  154.                  AX  19825                             SI  00000 
  155.                  BX  00000                             DI  00256 
  156.                  CX  00255                             BP  17113 
  157.                  DX  02596                             SP  00508 
  158.               
  159.                  CS  0AA4H   DS  0A54H   ES  0A24H   SS  0A34H   IP  0018H 
  160.               
  161.                  OF   DF  IEF   TF   SF   ZF   AF   PF   CF 
  162.                        +    x         +    x         E            COUNT  00003
  163.  
  164.              -----------------------------------------------------------------
  165.               
  166.              The PC Assembler Helper   Version 1.0 
  167.              Copyright (C) 1989  Chuck Nelson   All rights reserved. 
  168.              Enter a two byte hex number  4df9 
  169.              Enter any decimal number  +19825 
  170.              Enter a two byte hex number 
  171.  
  172.  
  173.              *****************************************************************
  174.  
  175.              This is how the screen looks after entering first a hex number,
  176.              then a decimal number. The numbers in the registers will probably
  177.              be different for you. Note that AX contains the last number that
  178.              was entered. On the left side you will see the AX, BX, CX and DX
  179.              ____________________
  180.  
  181.                 1 To make a blue background and white letters, insert the code
  182.              "call  set_blue" before the FIRST "call show_regs". i.e.:
  183.  
  184.                       call  set_blue
  185.                       call  show_regs
  186.  
  187.                  label_one:
  188.                       etc.
  189.  
  190.              This only works if it is allowed by the video board.
  191.  
  192.  
  193.  
  194.  
  195.              Chapter 3 - ASMHELP.OBJ                                        19
  196.              _______________________
  197.  
  198.              registers. For the time being, these registers will display
  199.              unsigned numbers. On the right are the SI, DI, BP and SP
  200.              registers. They are also unsigned numbers for the moment. Below
  201.              that are the segment registers CS, DS, ES, and SS and the
  202.              instruction pointer (IP). These are hex numbers and will always
  203.              be hex numbers. The bottom line has OF, DF, IEF, etc.  These are
  204.              the flags, and the marking underneath them (either a blank or
  205.              some character) tells how they are set. Finally we have COUNT.
  206.              This has nothing to do with the 8086. It is a counter that is
  207.              incremented each time you call show_regs. 
  208.  
  209.              Keep entering numbers and watch the registers. You will notice
  210.              that three things are changing - AX, IP and COUNT. AX has the
  211.              last number you entered and IP keeps changing. Write down the
  212.              value of IP each time it changes. It goes back and forth between
  213.              two numbers. That is because you call show_regs in two different
  214.              places in the loop, {2} and those are two different places in
  215.              memory where the 8086 is reading the machine code. 
  216.  
  217.              Why is AX changing? You may have wondered in prog1.asm and
  218.              prog2.asm how that information was going back and forth between
  219.              your program and asmhelp.obj. The answer is that in all the
  220.              programs in asmhelp.obj, if you need to pass information, it is
  221.              passed via register AX. This is not the normal way to pass
  222.              information. The normal way is more elegant but more complicated.
  223.              We will cover that much later. The counter, of course, increases
  224.              by 1 each time you call show_regs.
  225.  
  226.              Try entering a few more numbers and then it's time to go on to
  227.              the next program. 
  228.  
  229.  
  230.              MOVING DATA
  231.  
  232.              Obviously, we want to move data from memory to the 8086, from the
  233.              8086 to memory, and between registers. We have the following
  234.              possibilities: 
  235.  
  236.                  (1)  move from a register to memory
  237.                  (2)  move from memory to a register
  238.                  (3)  move a constant to memory
  239.                  (4)  move a constant to a register
  240.                  (5)  move from one register to another register
  241.  
  242.              That's it. There is no 8086 instruction that moves a single word
  243.              or a byte from one place in memory to another.
  244.  
  245.              The move mnemonic for the 8086 is "mov".{3}  We need some sample
  246.              data:
  247.              ____________________
  248.  
  249.                 2 IP actually has three different values, since you call
  250.              show_regs once before you enter the loop.
  251.  
  252.                 3 A mnemonic is a name for a machine instruction, which sounds
  253.              like what the instruction is supposed to do - MOV for move, SUB
  254.              for subtract, IMUL for integer multiplication, etc.
  255.  
  256.  
  257.  
  258.  
  259.              The PC Assembler Tutor                                         20
  260.              ______________________
  261.  
  262.  
  263.              EXAMPLE DATA
  264.  
  265.              this_year     dw   1989
  266.              total         dw   ?
  267.              average       dw   ?
  268.              time          dw   7
  269.  
  270.              age           db   ?         ; I hope you aren't older than 255
  271.              poem          db   "In 1492 Columbus played a mean kazoo."
  272.              secret_code   db   3Bh
  273.              character     db   ?
  274.  
  275.              Here is some sample code. To move from register to memory, we
  276.              have:
  277.  
  278.                       mov  total, ax
  279.                       mov  time, si
  280.                       mov  age, cl    
  281.                       mov  character, bh
  282.  
  283.              The first thing that strikes the eye is that the destination is
  284.              on the left and the source is on the right.{4}  This is standard
  285.              for the 8086 instruction set, and it's going to take some getting
  286.              used to. DESTINATION ON LEFT, SOURCE ON RIGHT. You are going to
  287.              blow this one from time to time, so always double check to make
  288.              sure that they are in the right order. 
  289.  
  290.              Also note that the 1 byte registers are matched up with 1 byte
  291.              variables, and 2 byte registers are matched up with 2 byte data.
  292.              If the sizes don't match, the assembler will complain.{5}  Thus:
  293.  
  294.                       mov  age, ax
  295.  
  296.              is an illegal instruction.
  297.  
  298.              For examples of memory to register moves, we have:
  299.  
  300.                       mov  ch, secret_code
  301.                       mov  di, this_year
  302.                       mov  dl, poem       ; moves 'I' to dl
  303.                       mov  bx, time
  304.              ____________________
  305.  
  306.                 4 The computer community likes the words "destination" and
  307.              "source". "Source" means FROM, and "destination" means TO. The
  308.              8086 instruction set is designed:
  309.  
  310.                  MOV  TO, FROM
  311.  
  312.              which is exactly opposite to the way you would say it in an
  313.              English sentence. For the 8086, it is always destination on the
  314.              left, source on the right. 
  315.  
  316.                 5 Half register and full register operations have different
  317.              machine codes, and the assembler needs to know which code to use,
  318.              so the two things must be the same number of bytes. 
  319.  
  320.  
  321.  
  322.  
  323.              Chapter 3 - ASMHELP.OBJ                                        21
  324.              _______________________
  325.  
  326.  
  327.              Once again: (1) DESTINATION ON LEFT, SOURCE ON RIGHT, and (2) the
  328.              sizes of the two objects must match.
  329.  
  330.              For constant to memory we have:
  331.  
  332.                       mov  total, 2986
  333.                       mov  age, 36h
  334.                       mov  secret_code, 0110100b
  335.                       mov  average, (27/5) + 3
  336.  
  337.              The arithmetic is done by the assembler and anything that is made
  338.              up totally of constants is legal. Thus:
  339.  
  340.                       mov  average, (((64+27)*51 )/(196-82))
  341.  
  342.              is legal but:
  343.  
  344.                       mov  average, this_year/time
  345.  
  346.              is illegal. The assembler makes either a one byte or a two byte
  347.              constant to match the size of the destination. The constants for
  348.              "total" and "average" are two byte constants while those for
  349.              "age" and "secret_code" are one byte constants. The constants
  350.              must be within range, that is -129 is too negative for a byte,
  351.              256 is too positive for a byte, -32769 is too negative for a
  352.              word, 65536 is too positive for a word. The assembler will give
  353.              an error if the constant is out of range.
  354.  
  355.              You can also move a constant to a register:
  356.  
  357.                       mov  al, 'c'
  358.                       mov  ax, 'c'
  359.                       mov  di, 46280
  360.                       mov  bl, 99
  361.  
  362.              The same rules apply. The constant must be within range and the
  363.              assembler will make a constant the same size as the destination
  364.              register (one or two bytes). These constants are actually
  365.              imbedded in the machine code by the assembler, and are
  366.              unchangable.
  367.  
  368.              Lastly, you can move data from one register to another:
  369.  
  370.                       mov  ax, cx         ; from cx to ax
  371.                       mov  ah, bl         ; from bl to ah
  372.                       mov  dl, dh         ; from dh to dl
  373.                       mov  di, dx         ; from dx to di
  374.  
  375.              All this is summarized at the end of the chapter.
  376.  
  377.  
  378.              It's time for program #4. All this program is going to do is get
  379.              input and the move it to different registers. We are still using
  380.              temp2.asm. Here's the program:
  381.  
  382.              TEMP2.ASM
  383.  
  384.  
  385.  
  386.  
  387.              The PC Assembler Tutor                                         22
  388.              ______________________
  389.  
  390.              ;+ + + + + + + + + + START DATA BELOW THIS LINE
  391.  
  392.              byte_data  db ?
  393.              word_data  dw ?
  394.  
  395.              ;+ + + + + + + + + + END DATA ABOVE THIS LINE
  396.  
  397.              ;+ + + + + + + + + + START CODE BELOW THIS LINE
  398.  
  399.                  call show_regs
  400.  
  401.              This_is_a_very_long_label_name:
  402.                  call get_hex                       ; (1)
  403.                  call show_regs_and_wait
  404.  
  405.                  mov  dx, ax                        ; (2)
  406.                  call show_regs_and_wait
  407.  
  408.                  mov  byte_data, al                 ; (3)
  409.                  mov  ch, byte_data
  410.                  call show_regs_and_wait
  411.  
  412.                  mov  word_data, ax                 ; (4)
  413.                  mov  di, word_data
  414.                  call show_regs
  415.  
  416.                  jmp  This_is_a_very_long_label_name
  417.  
  418.              ;+ + + + + + + + + + END CODE ABOVE THIS LINE
  419.  
  420.              There is a data section in this one, so copy those variables into
  421.              your data section. Here is what the program does. (1) it gets a
  422.              hex number from the keyboard, (2) it moves the number in ax to
  423.              dx, (3) it moves one byte from al to ch via the variable
  424.              byte_data, and (4) it moves two bytes from ax to di via
  425.              word_data.
  426.  
  427.              There are two different subprograms - show_regs and
  428.              show_regs_and_wait. They do the same thing except that
  429.              show_regs_and_wait waits for you to hit the ENTER key before
  430.              continuing. The computer works so fast that we wouldn't be able
  431.              to see the changes in the screen if we didn't have a way of
  432.              pausing. You can use COUNT on the screen to keep track of exactly
  433.              where you are in the loop.
  434.  
  435.              Assemble program 4, link it to asmhelp.obj, and watch it work.
  436.              There are two things to notice here. First, we are entering a hex
  437.              number, but AX is displaying an unsigned number. It is not
  438.              self-evident that the unsigned number in AX is the same as the
  439.              hex number that you are entering. Secondly, though CH is
  440.              changing, there doesn't seem to be any relationship between the
  441.              number in AX and the number in CX. We will solve both problems in
  442.              the next chapter.
  443.  
  444.  
  445.  
  446.  
  447.  
  448.  
  449.  
  450.  
  451.              Chapter 3 - ASMHELP.OBJ                                        23
  452.              _______________________
  453.  
  454.                                           SUMMARY
  455.  
  456.  
  457.                            MOVING DATA
  458.  
  459.              You can:
  460.                  (1)  move from a register to memory
  461.                  (2)  move from memory to a register
  462.                  (3)  move a constant to memory
  463.                  (4)  move a constant to a register
  464.                  (5)  move from one register to another register
  465.  
  466.                  The constants are actual constants which are imbedded in the
  467.                  machine code.
  468.  
  469.                            REGISTERS
  470.  
  471.              The normal registers are AX, BX, CX, DX, SI, DI AND BP. AX, BX,
  472.              CX, and DX can be divided into AH-AL, BH-BL, CH-CL AND DH-DL. The
  473.              'H' is for high and the 'L' is for low.
  474.              SP is committed and may not be used.
  475.              The segment registers are CS, DS, ES, SS.
  476.              The instruction pointer (IP) is not available to you.
  477.              The register that holds the flags is manipulated by special
  478.              machine instructions.
  479.  
  480.  
  481.  
  482.                            ASMHELP.OBJ
  483.  
  484.              Call show_regs to see what is in the 8086 registers. Count
  485.              increments by one every time you call show_regs. 
  486.  
  487.              show_regs_and_wait is the same as show_regs except that it waits
  488.              for you to hit the ENTER key to allow you time to look at the
  489.              screen.
  490.  
  491.              Call set_blue at the outset if you have a color card and a color
  492.              monitor and you want to have a blue background.
  493.  
  494.              get_num gets a signed or unsigned number from the keyboard. (1-5
  495.              digits). It does no range checking to see whether the number is
  496.              too big. All other input routines check to see if a number is too
  497.              large for its data size.
  498.  
  499.              get_hex gets a hex number from the keyboard.  (1-4 digits)
  500.  
  501.              get_ascii gets characters from the keyboard.  (1 or 2 characters)
  502.  
  503.              get_binary gets a binary number from the keyboard (1 - 16 digits)
  504.  
  505.              print_num prints a number as hex, signed, unsigned, char, and
  506.              binary.
  507.  
  508.              All data transfer to or from ASMHELP.OBJ is via the AX register.
  509.  
  510.